package docprocessor

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"time"

	"mcp-server/internal/docprocessor/parsers"
	"mcp-server/internal/docprocessor/splitter"
	"mcp-server/internal/types"
)

// DocumentProcessor 文档处理器
type DocumentProcessor struct {
	parsers  map[string]types.FileParser
	splitter types.TextSplitter
	config   *types.SplitConfig
}

// NewDocumentProcessor 创建文档处理器
func NewDocumentProcessor() *DocumentProcessor {
	processor := &DocumentProcessor{
		parsers:  make(map[string]types.FileParser),
		splitter: splitter.NewChineseSplitter(),
		config:   types.DefaultSplitConfig(),
	}

	// 注册解析器
	processor.registerParsers()

	return processor
}

// registerParsers 注册文件解析器
func (dp *DocumentProcessor) registerParsers() {
	// 注册TXT解析器
	txtParser := parsers.NewTxtParser()
	for _, ext := range txtParser.SupportedExtensions() {
		dp.parsers[ext] = txtParser
	}

	// 注册Markdown解析器
	mdParser := parsers.NewMdParser()
	for _, ext := range mdParser.SupportedExtensions() {
		dp.parsers[ext] = mdParser
	}
}

// ProcessFile 处理单个文件
func (dp *DocumentProcessor) ProcessFile(filePath string) (*types.SplitResult, error) {
	return dp.ProcessFileWithConfig(filePath, dp.config)
}

// ProcessFileWithConfig 使用指定配置处理文件
func (dp *DocumentProcessor) ProcessFileWithConfig(filePath string, config *types.SplitConfig) (*types.SplitResult, error) {
	startTime := time.Now()

	// 检查文件是否存在
	fileInfo, err := os.Stat(filePath)
	if err != nil {
		return nil, fmt.Errorf("文件访问失败: %v", err)
	}

	// 获取文件扩展名
	ext := strings.ToLower(filepath.Ext(filePath))
	parser, exists := dp.parsers[ext]
	if !exists {
		return nil, fmt.Errorf("不支持的文件类型: %s", ext)
	}

	// 解析文件内容
	content, err := parser.Parse(filePath)
	if err != nil {
		return nil, fmt.Errorf("文件解析失败: %v", err)
	}

	// 创建文件元数据
	metadata := map[string]string{
		"file_path": filePath,
		"file_name": filepath.Base(filePath),
		"file_type": ext,
		"file_size": fmt.Sprintf("%d", fileInfo.Size()),
	}

	// 执行分片
	result, err := dp.splitter.SplitWithMetadata(content, metadata, config)
	if err != nil {
		return nil, fmt.Errorf("文本分片失败: %v", err)
	}

	// 完善文档信息
	if result.Document != nil {
		result.Document.FilePath = filePath
		result.Document.FileName = filepath.Base(filePath)
		result.Document.FileSize = fileInfo.Size()
		result.Document.FileType = ext
		result.Document.ProcessTime = time.Since(startTime).Milliseconds()
	}

	return result, nil
}

// ProcessDirectory 处理目录中的所有支持文件
func (dp *DocumentProcessor) ProcessDirectory(dirPath string, recursive bool) ([]*types.SplitResult, error) {
	var results []*types.SplitResult

	err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		// 跳过目录
		if info.IsDir() {
			if !recursive && path != dirPath {
				return filepath.SkipDir
			}
			return nil
		}

		// 检查是否为支持的文件类型
		ext := strings.ToLower(filepath.Ext(path))
		if _, exists := dp.parsers[ext]; !exists {
			return nil // 跳过不支持的文件
		}

		// 处理文件
		result, err := dp.ProcessFile(path)
		if err != nil {
			fmt.Printf("处理文件失败 %s: %v\n", path, err)
			return nil // 继续处理其他文件
		}

		results = append(results, result)
		return nil
	})

	if err != nil {
		return nil, fmt.Errorf("目录遍历失败: %v", err)
	}

	return results, nil
}

// SetConfig 设置分片配置
func (dp *DocumentProcessor) SetConfig(config *types.SplitConfig) {
	if config != nil {
		dp.config = config
	}
}

// GetConfig 获取当前配置
func (dp *DocumentProcessor) GetConfig() *types.SplitConfig {
	return dp.config
}

// SetSplitter 设置文本分片器
func (dp *DocumentProcessor) SetSplitter(splitter types.TextSplitter) {
	if splitter != nil {
		dp.splitter = splitter
	}
}

// RegisterParser 注册文件解析器
func (dp *DocumentProcessor) RegisterParser(extensions []string, parser types.FileParser) {
	for _, ext := range extensions {
		dp.parsers[strings.ToLower(ext)] = parser
	}
}

// GetSupportedExtensions 获取支持的文件扩展名
func (dp *DocumentProcessor) GetSupportedExtensions() []string {
	var extensions []string
	for ext := range dp.parsers {
		extensions = append(extensions, ext)
	}
	return extensions
}

// ValidateConfig 验证配置
func (dp *DocumentProcessor) ValidateConfig(config *types.SplitConfig) error {
	if config == nil {
		return fmt.Errorf("配置不能为空")
	}

	if config.MaxChunkSize <= 0 {
		return fmt.Errorf("最大分片大小必须大于0")
	}

	if config.MinChunkSize <= 0 {
		return fmt.Errorf("最小分片大小必须大于0")
	}

	if config.MinChunkSize >= config.MaxChunkSize {
		return fmt.Errorf("最小分片大小必须小于最大分片大小")
	}

	if config.OverlapSize < 0 {
		return fmt.Errorf("重叠大小不能为负数")
	}

	if config.OverlapSize >= config.MinChunkSize {
		return fmt.Errorf("重叠大小必须小于最小分片大小")
	}

	return nil
}

// GetStatistics 获取处理统计信息
func (dp *DocumentProcessor) GetStatistics(results []*types.SplitResult) map[string]interface{} {
	stats := make(map[string]interface{})

	totalFiles := len(results)
	totalChunks := 0
	totalProcessTime := int64(0)
	successCount := 0
	failureCount := 0

	for _, result := range results {
		if result.Success {
			successCount++
			totalChunks += len(result.Chunks)
			if result.Document != nil {
				totalProcessTime += result.Document.ProcessTime
			}
		} else {
			failureCount++
		}
	}

	stats["total_files"] = totalFiles
	stats["success_count"] = successCount
	stats["failure_count"] = failureCount
	stats["total_chunks"] = totalChunks
	stats["total_process_time_ms"] = totalProcessTime
	stats["average_chunks_per_file"] = float64(totalChunks) / float64(successCount)

	if successCount > 0 {
		stats["average_process_time_ms"] = float64(totalProcessTime) / float64(successCount)
	}

	return stats
}
